- Skip symlinked entries that resolve outside the searched root during
  recursive grep_file, in both the Go and Python implementations. A
  symlink inside an otherwise-jailed directory (e.g. from an untrusted
  skill package) could previously be followed to read file contents
  outside the intended sandbox.
- Bound the Go grep scanner's line buffer (was capped at the default
  64KiB bufio.Scanner token size, which errored on long lines such as
  minified JSON).
- Reject an empty path explicitly in the Go grep_file tool instead of
  surfacing a confusing "no file path provided" error from deeper in
  the call stack.

Signed-off-by: brandonkeung <brandonlkeung@gmail.com>

Adds the two new tools to the quick-start import example and the
Tool Workflow table, and notes the symlink-escape protection in the
Security section, matching how the existing read_file/write_file/
edit_file/bash tools are already documented there.

Signed-off-by: brandonkeung <brandonlkeung@gmail.com>

Thermos branch review turned up a real bug introduced by the previous
symlink-escape fix, plus a consolidation opportunity and a missing
timeout:

- Go: `root, err := filepath.EvalSymlinks(path)` inside GrepContent's
  `if info.IsDir()` block shadowed the outer `err`, so a WalkDir
  failure was never observed by the `err != nil` check afterward.
  Combined with an in-bounds directory symlink (which WalkDir doesn't
  recurse into, and which grepFile can't read as a file), this caused
  the walk to abort silently partway through, returning a truncated
  "success" result with no error. Fixed by not shadowing err, and by
  explicitly skipping symlinked directories instead of letting
  grepFile fail on them.
- Go: consolidated the symlink-escape containment check into a single
  shared `skillruntime.WithinRoot` helper (previously GrepContent had
  its own filepath.Rel-based check, duplicating the pre-existing
  isWithinRoot used by resolveReadPath/resolveEditPath/resolveWritePath)
  so there's one implementation of this security-relevant property
  instead of two that could drift.
- Python: grep_file's regex match now runs via asyncio.to_thread with
  a 30s asyncio.wait_for timeout, mirroring the timeout bash already
  enforces. Python's re engine backtracks and a pathological,
  agent-controlled pattern run synchronously inside an async def could
  otherwise block the whole event loop indefinitely (Go is unaffected;
  its regexp package is RE2-based and linear-time).
- Mention list_files/grep_file in the bash tool's own description in
  both languages, and log (debug level) when bash is omitted because
  the sandbox-runtime isn't configured, so its absence isn't silent.

Verified live: both Go and Python runtime pods rebuilt and redeployed,
confirmed via the UI that a recursive grep_file across a working
directory containing the skills/ symlink (the exact scenario the
shadowing bug silently broke) now correctly finds matches on both
sides of the symlink.

Signed-off-by: brandonkeung <brandonlkeung@gmail.com>

…d failures

Across several review passes on grep_file/list_files, close out the
remaining correctness gaps in the recursive-search path (Go and Python):

- Fix filepath.WalkDir root resolution so an unresolved symlink root is
  actually recursed into, and fix an err-shadowing bug that silently
  truncated results on a WalkDir failure.
- Skip non-regular files (FIFOs, sockets, devices) before opening them --
  previously a FIFO with no writer connected would hang the search
  indefinitely, in both the recursive walk and single-target paths.
- Cap matched lines to 2000 chars (matching read_file's existing
  convention); previously unbounded in Python and could fail the whole
  search past 1MB in Go.
- Give GrepFileTool a dedicated thread pool in Python instead of the
  shared default pool, since a hung regex match can't be forcibly killed
  and would otherwise starve unrelated work.
- Treat a single unreadable file or subdirectory as a skip rather than
  aborting the whole search, so one bad entry doesn't discard matches
  already found elsewhere in the tree. Annotate "no matches found (N
  entries could not be read)" when skips occurred, so a systemic failure
  isn't indistinguishable from a genuinely empty search.
- Surface a real error, instead of a misleadingly confident empty
  result, when the search root itself is unreadable.
- Extract Go's classifyWalkEntry and Python's _resolve_working_path
  helpers to keep the now-more-involved walk logic readable.

Regression tests added for each fix above, verified to fail against the
prior code.

Signed-off-by: brandonkeung <brandonlkeung@gmail.com>